const { BrowserWindow, dialog, ipcMain, Menu, shell } = require('electron')
const path = require('path')
const { app } = require('electron')
const windowConfig = require('./utils/config').window
const { exec } = require('child_process')


// 保持对窗口对象的全局引用
let mainWindow
let isTransparent = false
let isAltPressed = false
let floatingBallWindow = null
let splashWindow = null
// 添加全局变量，用于存储最新的应用列表
let globalLauncherApps = null

/**
 * 创建启动屏幕
 * 
 * 该函数负责创建一个无边框、透明的启动屏幕窗口，显示应用程序加载进度和状态
 * 启动屏幕会在主窗口准备好后自动关闭
 * 
 * @returns {BrowserWindow} 返回创建的启动屏幕窗口
 */
function createSplashScreen() {
  // 创建一个新的浏览器窗口作为启动屏幕
  splashWindow = new BrowserWindow({
    width: 480,
    height: 320,
    frame: false,        // 无边框窗口
    transparent: true,   // 支持透明背景
    resizable: false,    // 禁止调整大小
    center: true,        // 居中显示
    alwaysOnTop: true,   // 置顶显示确保可见
    skipTaskbar: true,   // 在任务栏中隐藏
    show: false,         // 先创建不显示，加载完再显示
    webPreferences: {
      nodeIntegration: true,      // 启用Node集成
      contextIsolation: false,    // 禁用上下文隔离
      enableRemoteModule: true,   // 启用远程模块 (如果需要)
      devTools: false             // 禁用开发者工具
    }
  });

  // 加载启动屏幕HTML
  splashWindow.loadFile('splash.html')
    .then(() => {
      // 加载完成后再显示窗口，避免白屏闪烁
      splashWindow.show();
    })
    .catch(err => {
      console.error('加载启动屏幕失败:', err);
    });

  // 禁用菜单
  splashWindow.setMenu(null);

  // 处理窗口关闭事件
  splashWindow.on('closed', () => {
    splashWindow = null;
  });

  // 添加IPC监听器，处理从渲染进程发送的关闭启动屏幕请求
  ipcMain.on('close-splash-screen', () => {
    if (splashWindow && !splashWindow.isDestroyed()) {
      splashWindow.close();
    }
  });

  return splashWindow;
}

// 获取资源文件路径
function getAssetPath(assetName) {
  // 判断是否是打包环境
  if (app.isPackaged) {
    // 在打包环境中，资源文件位于 resources/build 目录下
    return path.join(process.resourcesPath, 'build', assetName)
  } else {
    // 在开发环境中，资源文件位于 build 目录下
    return path.join(__dirname, '..', '..', 'build', assetName)
  }
}

// 添加关于对话框函数
function showAboutDialog() {
  dialog.showMessageBox(mainWindow, {
    type: 'info',
    title: '关于',
    message: '桌面工具集成',
    detail: `版本：${app.getVersion()}\n作者：Rongo\n版权所有 © 2024`,
    buttons: ['确定'],
    icon: getAssetPath('icon.ico')
  })
}

// 切换透明状态
function toggleTransparency() {
  if (!mainWindow) return

  isTransparent = !isTransparent

  if (isTransparent) {
    // 设置窗口透明
    mainWindow.setAlwaysOnTop(false) // 取消置顶
    mainWindow.setVisibleOnAllWorkspaces(true)
    mainWindow.setOpacity(0.3)
    mainWindow.setIgnoreMouseEvents(true)
  } else {
    // 恢复窗口正常状态
    mainWindow.setAlwaysOnTop(false)
    mainWindow.setVisibleOnAllWorkspaces(false)
    mainWindow.setOpacity(1)
    mainWindow.setIgnoreMouseEvents(false)
  }
}

// 处理 ALT 键按下
function handleAltKeyDown() {
  if (isTransparent && mainWindow) {
    isAltPressed = true
    mainWindow.setIgnoreMouseEvents(false)
    mainWindow.setOpacity(0.8)
    mainWindow.setAlwaysOnTop(true) // 临时置顶
  }
}

// 处理 ALT 键释放
function handleAltKeyUp() {
  if (isTransparent && mainWindow) {
    isAltPressed = false
    mainWindow.setIgnoreMouseEvents(true)
    mainWindow.setOpacity(0.3)
    mainWindow.setAlwaysOnTop(false) // 取消置顶
  }
}

/**
 * 创建主应用窗口
 * 
 * 该函数负责创建主应用窗口，初始时为隐藏状态，等待ready-to-show事件后显示
 * 如有启动屏幕，主窗口会发送消息给启动屏幕，然后等待启动屏幕的动画完成
 */
function createWindow(splashWindow) {
  const { loadConfig } = require('./utils/config')
  const { Menu } = require('electron')
  const { getMenuTemplate } = require('./menu')
  const cachePath = path.join(app.getPath('userData'), 'cache')

  // 创建浏览器窗口
  mainWindow = new BrowserWindow({
    width: windowConfig.width,
    height: windowConfig.height,
    minWidth: windowConfig.minWidth,
    minHeight: windowConfig.minHeight,
    skipTaskbar: windowConfig.skipTaskbar,
    show: false, // 先不显示主窗口，等待准备好后显示
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false,
      devTools: true,  // 启用开发者工具
      partition: 'persist:main',  // 使用持久化的缓存分区
      cache: cachePath,  // 设置缓存路径
      userGesture: true  // 允许非用户手势触发的全屏操作
    }
  })

  // 创建菜单
  const menu = Menu.buildFromTemplate(getMenuTemplate())
  Menu.setApplicationMenu(menu)

  // 加载应用的 index.html
  mainWindow.loadFile('index.html')

  // 禁用右键菜单
  mainWindow.webContents.on('context-menu', (e) => {
    e.preventDefault()
  })

  // 监听窗口准备好显示的事件
  mainWindow.once('ready-to-show', () => {
    console.log('主窗口准备就绪...');
    // 如果启动屏幕存在，发送消息通知启动屏幕主窗口已准备好
    if (splashWindow && !splashWindow.isDestroyed()) {
      console.log('启动屏幕存在，发送主窗口就绪消息...');
      // 向启动屏幕发送主窗口已准备好的消息
      splashWindow.webContents.send('main-window-ready');

      // 为确保顺序正确，使用短暂延迟后显示主窗口
      // 延迟应略长于启动屏幕的淡出动画时间，确保平滑过渡
      setTimeout(() => {
        console.log('显示主窗口...');
        mainWindow.show();
        // 根据配置决定是否最大化窗口
        if (windowConfig.startMaximized) {
          mainWindow.maximize();
        }
        mainWindow.focus();
      }, 1300); // 比启动屏幕淡出动画(800ms)稍长，确保平滑过渡
    } else {
      // 如果没有启动屏幕，直接显示主窗口
      console.log('无启动屏幕，直接显示主窗口...');
      mainWindow.show();
      mainWindow.focus();
    }
  });

  // 当窗口关闭时触发
  mainWindow.on('closed', function () {
    mainWindow = null
  })

  // 加载配置并发送到渲染进程
  const appConfig = loadConfig()
  mainWindow.webContents.on('did-finish-load', () => {
    mainWindow.webContents.send('config-loaded', appConfig)
  })

  return mainWindow
}

// 处理悬浮球显示/隐藏
function toggleFloatingBall() {
  if (floatingBallWindow && !floatingBallWindow.isDestroyed()) {
    if (floatingBallWindow.isVisible()) {
      floatingBallWindow.hide()
    } else {
      floatingBallWindow.show()
    }
  } else {
    createFloatingBall()
  }
}
// 创建悬浮球窗口
function createFloatingBall() {
  if (floatingBallWindow) {
    floatingBallWindow.show()
    return
  }

  floatingBallWindow = new BrowserWindow({
    width: 50,
    height: 50,
    frame: false,
    transparent: true,
    alwaysOnTop: true,
    skipTaskbar: true,
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false,
      devTools: true  // 启用开发者工具
    }
  })

  // 加载悬浮球HTML
  floatingBallWindow.loadFile('floatingBall.html')

  // 设置初始位置（右下角）
  const { width, height } = require('electron').screen.getPrimaryDisplay().workAreaSize
  floatingBallWindow.setPosition(width - 60, height - 60)

  // 处理拖动事件
  ipcMain.on('drag-floating-ball', (event, { x, y }) => {
    if (floatingBallWindow && !floatingBallWindow.isDestroyed()) {
      floatingBallWindow.setPosition(x - 25, y - 25)
    }
  })

  // 处理右键菜单事件
  ipcMain.on('show-floating-ball-context-menu', () => {
    const template = [
      {
        label: '打开主界面',
        click: () => {
          if (mainWindow) {
            if (mainWindow.isMinimized()) {
              mainWindow.restore()
            }
            mainWindow.show()
            mainWindow.focus()
          } else {
            createWindow()
          }
        }
      },
      { type: 'separator' },
      {
        label: '立即关机',
        click: () => {
          // 弹出确认对话框
          dialog.showMessageBox(floatingBallWindow, {
            type: 'warning',
            title: '确认关机',
            message: '确定要立即关机吗？',
            buttons: ['确定', '取消'],
            defaultId: 1,
            cancelId: 1
          }).then(result => {
            if (result.response === 0) {
              // 用户确认，执行关机
              if (process.platform === 'win32') {
                exec('shutdown -s -t 0', (err) => {
                  if (err) {
                    console.error('立即关机执行失败:', err);
                  }
                });
              } else if (process.platform === 'darwin') {
                exec('sudo shutdown -h now', (err) => {
                  if (err) {
                    console.error('立即关机执行失败:', err);
                  }
                });
              }
            }
          });
        }
      },
      {
        label: '重启',
        click: () => {
          // 弹出确认对话框
          dialog.showMessageBox(floatingBallWindow, {
            type: 'warning',
            title: '确认重启',
            message: '确定要重启计算机吗？',
            buttons: ['确定', '取消'],
            defaultId: 1,
            cancelId: 1
          }).then(result => {
            if (result.response === 0) {
              // 用户确认，执行重启
              if (process.platform === 'win32') {
                exec('shutdown -r -t 0', (err) => {
                  if (err) {
                    console.error('重启执行失败:', err);
                  }
                });
              } else if (process.platform === 'darwin') {
                exec('sudo shutdown -r now', (err) => {
                  if (err) {
                    console.error('重启执行失败:', err);
                  }
                });
              }
            }
          });
        }
      },
      { type: 'separator' },
      {
        label: '关闭悬浮球',
        click: () => {
          if (floatingBallWindow && !floatingBallWindow.isDestroyed()) {
            floatingBallWindow.hide()
          }
        }
      }
    ]

    const menu = Menu.buildFromTemplate(template)
    menu.popup({ window: floatingBallWindow })
  })

  // 添加快捷键打开开发者工具
  floatingBallWindow.webContents.on('before-input-event', (event, input) => {
    if (input.control && input.shift && input.key.toLowerCase() === 'i') {
      floatingBallWindow.webContents.openDevTools({ mode: 'detach' })
    }
  })

  // 处理点击事件
  ipcMain.on('show-quick-apps', () => {
    showQuickAppsWindow()
  })
}

// 创建快捷应用窗口
function showQuickAppsWindow() {
  const quickAppsWindow = new BrowserWindow({
    width: 220,
    height: 400,
    frame: false,
    transparent: true,
    alwaysOnTop: true,
    skipTaskbar: true,
    show: true,
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false,
      devTools: true  // 启用开发者工具
    }
  })

  // 加载快捷应用HTML
  quickAppsWindow.loadFile('quickApps.html')

  // 设置位置（悬浮球旁边）
  const ballBounds = floatingBallWindow.getBounds()
  quickAppsWindow.setPosition(ballBounds.x - 220, ballBounds.y - 400)

  // 在页面加载完成后，从主窗口获取数据并发送给快捷应用窗口
  quickAppsWindow.webContents.on('did-finish-load', () => {
    // 优先使用全局存储的最新数据
    if (globalLauncherApps) {
      quickAppsWindow.webContents.send('launcher-apps-data', globalLauncherApps);
    } else if (mainWindow && !mainWindow.isDestroyed()) {
      // 如果没有全局数据，则从主窗口获取
      mainWindow.webContents.executeJavaScript(`
        localStorage.getItem('launcherApps')
      `).then(launcherAppsStr => {
        globalLauncherApps = launcherAppsStr; // 更新全局变量
        quickAppsWindow.webContents.send('launcher-apps-data', launcherAppsStr);
      }).catch(error => {
        console.error('获取主窗口数据失败:', error);
      });
    }
  });

  // 添加快捷键打开开发者工具
  quickAppsWindow.webContents.on('before-input-event', (event, input) => {
    if (input.control && input.shift && input.key.toLowerCase() === 'i') {
      quickAppsWindow.webContents.openDevTools({ mode: 'detach' });
    }
  });

  // 监听应用点击事件
  ipcMain.once('launch-quick-app', (event, appPath) => {
    shell.openPath(appPath).catch(error => {
      console.error('应用启动失败:', error)
    })
    quickAppsWindow.close();
  });

  // 监听鼠标离开事件
  ipcMain.once('mouse-leave', () => {
    quickAppsWindow.close();
  });
}
module.exports = {
  createWindow,
  createSplashScreen,
  showAboutDialog,
  toggleTransparency,
  handleAltKeyDown,
  handleAltKeyUp,
  toggleFloatingBall,
  getAssetPath
}